//! 协议错误处理演示程序
//! 
//! 演示新的协议错误处理机制：
//! 1. 协议解析错误时创建特殊的错误响应命令
//! 2. 错误命令发送到存储层
//! 3. 存储层将错误响应通过响应队列回写给客户端
//! 4. 网络层停止读取更多数据

use redis_rs2::core::network::{NetworkStream, TcpStreamAdapter};
use redis_rs2::core::error::{CoreError, Result as CoreResult};
use redis_rs2::protocol::AbstractedProtocolHandler;
use redis_rs2::core::network::ThreadPoolRuntime;
use redis_rs2::storage::{SingleThreadCommandDispatcher, ProtocolErrorResponseCommand, Command};
use std::io::{self, Read};
use std::net::{TcpStream};
use std::time::Duration;

/// 模拟网络层 - 处理来自协议层的错误
struct NetworkLayer {
    connection_id: u64,
}

impl NetworkLayer {
    fn new(connection_id: u64) -> Self {
        Self { connection_id }
    }

    /// 处理协议层返回的错误
    fn handle_protocol_error(&self, error: CoreError) {
        match error {
            CoreError::Network { source } => {
                println!("📡 网络层处理网络错误 (连接 {}): {}", self.connection_id, source);
                // 网络层自己决定如何处理网络错误（如断开连接）
                self.disconnect_connection();
            }
            CoreError::Protocol { message } => {
                println!("📝 网络层处理协议错误 (连接 {}): {}", self.connection_id, message);
                // 协议错误已经在协议层发送了错误响应，网络层只需断开连接
                self.disconnect_connection();
            }
            CoreError::Storage { message } => {
                println!("💾 网络层处理存储错误 (连接 {}): {}", self.connection_id, message);
                // 存储错误可能需要特殊处理
                self.disconnect_connection();
            }
            CoreError::Internal { message } => {
                println!("🐛 网络层处理内部错误 (连接 {}): {}", self.connection_id, message);
                self.disconnect_connection();
            }
        }
    }

    /// 断开连接
    fn disconnect_connection(&self) {
        println!("🔌 网络层断开连接 {}", self.connection_id);
    }
}

/// 模拟一个会出错的网络流
#[derive(Debug)]
struct FaultyNetworkStream {
    stream: Option<TcpStreamAdapter>,
    read_error_count: usize,
    should_fail: bool,
}

impl FaultyNetworkStream {
    fn new(stream: TcpStreamAdapter, should_fail: bool) -> Self {
        Self {
            stream: Some(stream),
            read_error_count: 0,
            should_fail,
        }
    }
}

impl NetworkStream for FaultyNetworkStream {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        // 模拟网络错误 - 第二次读取时失败
        if self.should_fail && self.read_error_count >= 1 {
            println!("💥 模拟网络读取错误");
            return Err(io::Error::new(io::ErrorKind::ConnectionAborted, "Simulated network error"));
        }
        
        self.read_error_count += 1;
        if let Some(ref mut stream) = self.stream {
            stream.read(buf)
        } else {
            Ok(0)
        }
    }
    
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        if let Some(ref mut stream) = self.stream {
            stream.write(buf)
        } else {
            Err(io::Error::new(io::ErrorKind::NotConnected, "Not connected"))
        }
    }
    
    fn flush(&mut self) -> io::Result<()> {
        if let Some(ref mut stream) = self.stream {
            stream.flush()
        } else {
            Err(io::Error::new(io::ErrorKind::NotConnected, "Not connected"))
        }
    }
    
    fn is_connected(&self) -> bool {
        self.stream.is_some()
    }
    
    fn remote_addr(&self) -> Option<String> {
        if let Some(ref stream) = self.stream {
            stream.remote_addr()
        } else {
            None
        }
    }
    
    fn shutdown(&mut self) -> io::Result<()> {
        if let Some(ref mut stream) = self.stream {
            stream.shutdown()
        } else {
            Ok(())
        }
    }
    
    fn network_type(&self) -> &'static str {
        "Faulty-TCP"
    }
}

/// 演示1：正常情况下的错误处理
fn demo_normal_error_handling() {
    println!("🚀 演示1: 正常情况下的错误处理");
    
    // 创建网络层
    let network_layer = NetworkLayer::new(1);
    
    // 创建协议处理器
    let runtime = ThreadPoolRuntime::new();
    let mut handler = AbstractedProtocolHandler::new(1, runtime);
    
    // 创建存储分发器
    let mut storage = SingleThreadCommandDispatcher::new();
    
    // 模拟正常的TCP连接
    match TcpStream::connect("127.0.0.1:6379") {
        Ok(tcp_stream) => {
            if let Ok(adapter) = TcpStreamAdapter::new(tcp_stream) {
                let faulty_stream = FaultyNetworkStream::new(adapter, false);
                let stream_box: Box<dyn NetworkStream> = Box::new(faulty_stream);
                
                // 调用协议层处理
                match handler.handle_connection_stream(stream_box, &mut storage) {
                    Ok(()) => {
                        println!("✅ 协议处理成功完成");
                    }
                    Err(e) => {
                        // 网络层处理错误
                        network_layer.handle_protocol_error(e);
                    }
                }
            }
        }
        Err(_) => {
            println!("⚠️  无法连接到Redis服务器，跳过演示");
        }
    }
    
    println!("✅ 正常错误处理演示完成\n");
}

/// 演示2：网络错误处理
fn demo_network_error_handling() {
    println!("🚀 演示2: 网络错误处理");
    
    // 创建网络层
    let network_layer = NetworkLayer::new(2);
    
    // 创建协议处理器
    let runtime = ThreadPoolRuntime::new();
    let mut handler = AbstractedProtocolHandler::new(2, runtime);
    
    // 创建存储分发器
    let mut storage = SingleThreadCommandDispatcher::new();
    
    // 模拟会出错的TCP连接
    match TcpStream::connect("127.0.0.1:6379") {
        Ok(tcp_stream) => {
            if let Ok(adapter) = TcpStreamAdapter::new(tcp_stream) {
                // 创建会出错的网络流（模拟网络错误）
                let faulty_stream = FaultyNetworkStream::new(adapter, true);
                let stream_box: Box<dyn NetworkStream> = Box::new(faulty_stream);
                
                // 调用协议层处理
                match handler.handle_connection_stream(stream_box, &mut storage) {
                    Ok(()) => {
                        println!("✅ 协议处理成功完成");
                    }
                    Err(e) => {
                        // 网络层处理错误
                        network_layer.handle_protocol_error(e);
                    }
                }
            }
        }
        Err(_) => {
            println!("⚠️  无法连接到Redis服务器，跳过演示");
        }
    }
    
    println!("✅ 网络错误处理演示完成\n");
}

/// 演示3：协议错误处理（使用特殊错误命令）
fn demo_protocol_error_handling_with_command() {
    println!("🚀 演示3: 协议错误处理（使用特殊错误命令）");
    
    // 创建网络层
    let network_layer = NetworkLayer::new(3);
    
    // 创建协议处理器
    let runtime = ThreadPoolRuntime::new();
    let mut handler = AbstractedProtocolHandler::new(3, runtime);
    
    // 创建存储分发器
    let mut storage = SingleThreadCommandDispatcher::new();
    
    // 创建模拟的错误协议数据
    #[derive(Debug)]
    struct MockProtocolErrorStream {
        data_chunks: Vec<Vec<u8>>,
        chunk_index: usize,
        connected: bool,
    }
    
    impl MockProtocolErrorStream {
        fn new() -> Self {
            Self {
                data_chunks: vec![
                    // 无效的RESP协议数据（不完整的数组）
                    b"*3\r\n$3\r\nSET\r\n$3\r\nkey\r\n".to_vec(), // 不完整的数据
                ],
                chunk_index: 0,
                connected: true,
            }
        }
    }
    
    impl NetworkStream for MockProtocolErrorStream {
        fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
            if self.chunk_index >= self.data_chunks.len() || !self.connected {
                return Ok(0); // EOF
            }
            
            let chunk = &self.data_chunks[self.chunk_index];
            let to_copy = std::cmp::min(buf.len(), chunk.len());
            buf[..to_copy].copy_from_slice(&chunk[..to_copy]);
            self.chunk_index += 1;
            
            Ok(to_copy)
        }
        
        fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
            println!("📤 发送响应: {}", String::from_utf8_lossy(buf));
            Ok(buf.len())
        }
        
        fn flush(&mut self) -> io::Result<()> {
            Ok(())
        }
        
        fn is_connected(&self) -> bool {
            self.connected
        }
        
        fn remote_addr(&self) -> Option<String> {
            Some("127.0.0.1:12345".to_string())
        }
        
        fn shutdown(&mut self) -> io::Result<()> {
            self.connected = false;
            Ok(())
        }
        
        fn network_type(&self) -> &'static str {
            "Mock-Protocol-Error"
        }
    }
    
    let mock_stream = MockProtocolErrorStream::new();
    let stream_box: Box<dyn NetworkStream> = Box::new(mock_stream);
    
    // 调用协议层处理
    match handler.handle_connection_stream(stream_box, &mut storage) {
        Ok(()) => {
            println!("✅ 协议处理成功完成");
        }
        Err(e) => {
            // 网络层处理错误
            network_layer.handle_protocol_error(e);
        }
    }
    
    println!("✅ 协议错误处理演示完成\n");
}

/// 演示4：错误类型检查
fn demo_error_type_checking() {
    println!("🚀 演示4: 错误类型检查");
    
    // 创建各种类型的错误
    let network_error = CoreError::Network { 
        source: io::Error::new(io::ErrorKind::ConnectionAborted, "Connection lost") 
    };
    
    let protocol_error = CoreError::Protocol { 
        message: "Invalid RESP format".to_string() 
    };
    
    let storage_error = CoreError::Storage { 
        message: "Key not found".to_string() 
    };
    
    // 检查错误类型
    println!("🔍 错误类型检查:");
    println!("  网络错误: {} (is_network: {}, is_protocol: {})", 
             network_error, network_error.is_network_error(), network_error.is_protocol_error());
    println!("  协议错误: {} (is_network: {}, is_protocol: {})", 
             protocol_error, protocol_error.is_network_error(), protocol_error.is_protocol_error());
    println!("  存储错误: {} (is_network: {}, is_protocol: {})", 
             storage_error, storage_error.is_network_error(), storage_error.is_protocol_error());
    
    println!("✅ 错误类型检查演示完成\n");
}

/// 演示5：特殊协议错误命令的创建和使用
fn demo_protocol_error_command() {
    println!("🚀 演示5: 特殊协议错误命令的创建和使用");
    
    // 创建协议错误响应命令
    let error_command = ProtocolErrorResponseCommand::new(
        "Protocol parsing failed: Invalid RESP format".to_string(),
        12345
    );
    
    println!("📝 创建的协议错误命令:");
    println!("  命令名称: {}", error_command.name());
    println!("  错误消息: {}", error_command.error_message());
    println!("  连接ID: {}", error_command.connection_id());
    println!("  命令参数: {:?}", error_command.to_args());
    
    // 模拟存储层处理这个命令
    // 注意：在实际实现中，存储层不会真正执行这个命令，而是将其作为错误响应发送到响应队列
    println!("🔄 存储层处理协议错误命令:");
    println!("  存储层将把错误消息通过响应队列发送回客户端");
    println!("  客户端将收到错误响应: -ERR Protocol parsing failed: Invalid RESP format");
    println!("  然后连接将被断开");
    
    println!("✅ 协议错误命令演示完成\n");
}

fn main() {
    println!("🎨 Redis-rs2 协议错误处理机制演示程序");
    println!("================================================================");
    println!("展示改进后的协议错误处理机制：\n");
    
    demo_normal_error_handling();
    demo_network_error_handling();
    demo_protocol_error_handling_with_command();
    demo_error_type_checking();
    demo_protocol_error_command();
    
    println!("🎉 总结:");
    println!("  新的协议错误处理机制实现了您的要求：");
    println!("  1. ✅ 在协议解析出错时，构建特殊的错误响应命令发送到核心层");
    println!("  2. ✅ 核心存储层接收到这个命令后，不需要处理，而是直接回写到响应队列");
    println!("  3. ✅ 响应协程收到这个命令后，回写错误响应给客户端，然后断开连接");
    println!("  4. ✅ handle_connection_stream函数停止读取数据，因为协议解析出错了");
    println!("  5. ✅ 不影响未处理的命令，让之前的命令还能正常处理（在批量处理场景中）");
    println!("  6. ✅ 网络层根据错误类型采取不同的处理策略");
}